{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=6>超参数调优、Batch正则化和程序框架</font>\n",
    "# 超参数调优\n",
    "## 超参数\n",
    "1. $\\alpha$ 学习率\n",
    "4. Mini-batch的批次容量值\n",
    "6. Adam的$\\beta_1,\\beta_2和\\epsilon$\n",
    "5. Momentum的$\\beta$\n",
    "1. layers 网络层数\n",
    "2. hidden units 隐含层节点数\n",
    "\n",
    "## 调优方法\n",
    "1. 网格搜索和随机取值;\n",
    "2. 由粗糙到精确;\n",
    "<table>\n",
    "    <tr>\n",
    "        <td><img src=\"images/a4a36532a333a455248b7d7124bc50a5.png\"></td>\n",
    "        <td><img src=\"images/61891952e5f96569b04e8f3949e42fb7.png\"></td>\n",
    "    </tr>\n",
    "</table>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 为超参数选择合适的范围\n",
    "## 值域随机均匀选择\n",
    "1. layers 网络层数 eg.$L\\in[2,10]$\n",
    "2. hidden units 隐藏层节点数 eg.$n^{l}\\in[50,100]$\n",
    "\n",
    "## 幂次随机均匀选择\n",
    "1. $\\alpha$ 学习率,$\\alpha=10^{t},t\\in[-5,0]$\n",
    "5. Momentum的$\\beta=1-10^{t},t\\in[-5,-1]$\n",
    "6. Adam的$\\beta_1,\\beta_2和\\epsilon$\n",
    "4. etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 批归一化\n",
    "批归一化,简称$BN$(Batch Normalization).应用批归一化,可以是使神经网络对超参数的选择更加稳定，超参数的选择范围更加庞大，工作效果得到提升，也会是神经网络模型的训练更加容易，进而提高模型训练的效率.\n",
    "\n",
    "## 回顾逻辑回归的归一化\n",
    "**公式：**\n",
    "\n",
    "$\n",
    "\\mu=\\frac{1}{m}\\sum_iX^{(i)}\\\\\n",
    "X=X-\\mu\\\\\n",
    "\\sigma^{2}=\\frac{1}{m}\\sum_iX^{(i)2}\\\\\n",
    "X=\\frac{X}{\\sigma}\n",
    "$\n",
    "\n",
    "## 神经网络的批归一化\n",
    "归一化每一层的$z^{[l]}$值。\n",
    "\n",
    "**公式：**\n",
    "\n",
    "$\n",
    "\\mu=\\frac{1}{m}\\sum_iZ^{[l](i)}\\\\\n",
    "Z^{[l]}=Z^{[l]}-\\mu\\\\\n",
    "\\sigma^{2}=\\frac{1}{m}\\sum_iZ^{[l](i)2}\\\\\n",
    "Z^{[l]}=\\frac{Z^{[l]}}{\\sqrt{\\sigma^{2}+\\epsilon}}\n",
    "$\n",
    "## 批归一化的新参数\n",
    "令归一化之后的$Z^{[l]}$为$Z_{norm}^{[l]}$，$\\tilde Z^{[l]}=\\gamma Z_{norm}^{[l]}+\\beta$。我们对$\\gamma和\\beta$采用梯度下降法进行学习，可以找到最适合模型学习的分布形式。这里$\\gamma$和$\\beta$是我们模型的新的参数，它类似于$W和b$。\n",
    "\n",
    "$\\gamma和\\beta$作用就是缩放和平移样本空间。特别地，当$\\gamma= \\sqrt{\\sigma^{2} +\\varepsilon}$，$\\beta$等于$\\mu$，$\\tilde Z^{[l]}$就变回原始$Z^{[l]}$。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 批归一化神经网络：BN-NN\n",
    "## **公式：**\n",
    "\n",
    "$Z^{[l]}=W^{[l]}A^{[l-1]}+b^{[l]}\\tag{1}$\n",
    "\n",
    "$\\tilde Z^{[l]}=BN(\\gamma^{[l]},\\beta^{[l]},Z^{[l]})\\tag{2}$\n",
    "\n",
    "$A^{[l]}=g(\\tilde Z^{[l]})\\tag{3}$\n",
    "\n",
    "$w^{[l]} := w^{[l]} -\\text{αd}w^{[l]},\\gamma^{[l]} = \\gamma^{[l]} -{αd}\\gamma^{[l]},{\\beta}^{[l]}: = {\\beta}^{[l]} - \\alpha d{\\beta}^{[l]}\\tag{4}$\n",
    "\n",
    "## mini-batch\n",
    "将原来的全样本集，替换成样本子集。\n",
    "\n",
    "## 在归一化神经网络中，$b$的意义消失，可以去掉\n",
    "因为对Z^{[l]}做归一化的时候，样本的$b$和样本均值的$b$相互抵消。\n",
    "\n",
    "$Z^{[l]}=W^{[l]}A^{[l-1]}+b^{[l]}\\to Z^{[l]}=W^{[l]}A^{[l-1]}\\tag{1}$\n",
    "\n",
    "参数由$W,b$变为$W,\\gamma,\\beta$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 批归一化为什么起作用？\n",
    "1. 同输入层归一化的作用；\n",
    "2. 归一化每一层的$Z^{[l]}$,可以降低相邻两层之间参数的相互影响力，进而实现网络每一层都可以独立学习；\n",
    "3. mini-batch的批归一化会给均值和方差带来噪音（因为不是整体样本的均值和方差），和同dropout正则化一样能够带来一定程度的正则化效果，即拒绝依赖某个特征；"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 将批归一化模型应用于测试\n",
    "批归一化在训练集上是通过mini-batch的方法逐一训练学习。在预测测试集的时候，需要对样本逐一的预测，这需要用特殊的方法求解归一化用到的均值和方差。\n",
    "\n",
    "## 使用样本集总体的均值和方差\n",
    "\n",
    "## mini-batch，求均值和方差的指数加权均值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Softmax\n",
    "## 概念\n",
    "<img src=\"images/8cb7a9126e1c20bb49879239385bb77b.png\" width=80%>\n",
    "\n",
    "## 例\n",
    "$\\large z^{[L]} = \\begin{bmatrix} 5 \\\\ 2 \\\\  - 1 \\\\ 3 \\\\ \\end{bmatrix}\\to t =\\begin{bmatrix} e^{5} \\\\ e^{2} \\\\ e^{- 1} \\\\ e^{3} \\\\ \\end{bmatrix}= \\begin{bmatrix} 148.4 \\\\ 7.4 \\\\ 0.4 \\\\ 20.1 \\\\ \\end{bmatrix}\\to A^{[L]} = \\frac{t} {176.3}=\\begin{bmatrix} 0.842 \\\\ 0.042 \\\\ 0.002 \\\\ 0.114 \\\\ \\end{bmatrix}$\n",
    "\n",
    "## softmax的不同之处\n",
    "相较于sigmod、relu等激活函数，softmax激活函数不仅计算每个节点的输出值，而且对所有输出值进行归一化，最终输出概率。\n",
    "\n",
    "## 1层神经网络softmanx3分类\n",
    "<img src=\"images/1dc4bf21b6e38cbe9bdfb729ed969c99.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Softmax模型\n",
    "1. 标签不再是标量值，而是向量值，$y = \\begin{bmatrix}y_0\\\\y_1\\\\y_2\\\\y_3\\\\\\vdots \\end{bmatrix},\\hat y = \\begin{bmatrix}\\hat y_0\\\\\\hat y_1\\\\\\hat y_2\\\\\\hat y_3\\\\\\vdots  \\end{bmatrix}$\n",
    "2. 成本函数，$\\large J( w^{[1]},b^{[1]},\\ldots\\ldots) = -\\frac{1}{m}\\sum_{i = 0}^{m-1}{\\sum_{j = 0}^{n-1}{y^{(i)}_{j}log\\hat y^{(i)}_{j}}}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 深度学习框架\n",
    "<img src=\"images/acb3843cd1085b0742f39677289890a0.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TensorFlow\n",
    "## 环境准备"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 梯度下降\n",
    "$Jw= w^{2}-10w+25$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#定义参数w，在TensorFlow中，用tf.Variable()来定义参数\n",
    "w = tf.Variable(0,dtype = tf.float32)\n",
    "#定义损失函数：\n",
    "cost = tf.add(tf.add(w**2,tf.multiply(- 10.,w)),25)\n",
    "#用0.01的学习率，最小化损失值\n",
    "train = tf.train.GradientDescentOptimizer(0.01).minimize(cost)\n",
    "# 实例初始化类\n",
    "init = tf.global_variables_initializer()\n",
    "#开启了一个TensorFlow session会话\n",
    "session = tf.Session()\n",
    "#初始化全局变量。\n",
    "session.run(init)\n",
    "#TensorFlow估计变量\n",
    "session.run(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.099999994"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "session.run(train)\n",
    "session.run(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.9999886"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in range(1000):\n",
    "    session.run(train)\n",
    "session.run(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TensorFlow符号重载"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.9999886"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#定义参数w，在TensorFlow中，用tf.Variable()来定义参数\n",
    "w = tf.Variable(0,dtype = tf.float32)\n",
    "#定义损失函数：\n",
    "cost = w**2-10*w+25\n",
    "#用0.01的学习率，最小化损失值\n",
    "train = tf.train.GradientDescentOptimizer(0.01).minimize(cost)\n",
    "# 实例初始化类\n",
    "init = tf.global_variables_initializer()\n",
    "#开启了一个TensorFlow session会话\n",
    "session = tf.Session()\n",
    "#初始化全局变量。\n",
    "session.run(init)\n",
    "#TensorFlow估计变量\n",
    "for i in range(1000):\n",
    "    session.run(train)\n",
    "session.run(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 占位符\n",
    "```python\n",
    "x = tf.placeholder(tf.float32,[3,1])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.999977"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#定义参数w，在TensorFlow中，用tf.Variable()来定义参数\n",
    "# coefficients=np.array([[1.],[-10.],[25.]])\n",
    "coefficients=np.array([[1.],[-20.],[100.]])\n",
    "w = tf.Variable(0,dtype = tf.float32)\n",
    "x = tf.placeholder(tf.float32,[3,1])\n",
    "#定义损失函数：\n",
    "# cost = w**2-10*w+25\n",
    "cost=x[0,0]*w**2+x[1,0]*w+x[2,0]\n",
    "#用0.01的学习率，最小化损失值\n",
    "train = tf.train.GradientDescentOptimizer(0.01).minimize(cost)\n",
    "# 实例初始化类\n",
    "init = tf.global_variables_initializer()\n",
    "#开启了一个TensorFlow session会话\n",
    "session = tf.Session()\n",
    "#初始化全局变量。\n",
    "session.run(init)\n",
    "#TensorFlow估计变量\n",
    "for i in range(1000):\n",
    "    session.run(train,feed_dict={x:coefficients})\n",
    "session.run(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 常量\n",
    "$loss = \\mathcal{L}(\\hat{y}, y) = (\\hat y^{(i)} - y^{(i)})^2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "y_hat=tf.constant(25)\n",
    "y=tf.constant(28)\n",
    "loss=tf.Variable((y-y_hat)**2,name='loss')\n",
    "init = tf.global_variables_initializer()\n",
    "with tf.Session() as session:\n",
    "    session.run(init)\n",
    "    print(session.run(loss))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TensorFlow的流程\n",
    "1. 创建张量（常量，变量）；\n",
    "2. 创建张量组成的函数；\n",
    "3. 实例化初始化类，实例化Session会话；\n",
    "4. 初始化操作；\n",
    "5. 运行函数求解；"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Mul_4:0' shape=() dtype=int32>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=tf.constant(2)\n",
    "b=tf.constant(3)\n",
    "c=tf.multiply(a,b)\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.Session().run(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**总结：**\n",
    "创建张量-创建Session-运行函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=tf.placeholder(tf.int64,[1,2])\n",
    "tf.Session().run(x[0,0]*x[0,1],feed_dict={x:[[2,3]]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.Session().run(x[0,0]*x[0,1],feed_dict={x:[[4,3]]})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 线性函数\n",
    "$Y = WX + b$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_function():    \n",
    "    X = tf.constant(np.random.randn(3,1), name = \"X\")  \n",
    "    W = tf.constant(np.random.randn(4,3), name = \"W\")  \n",
    "    b = tf.constant(np.random.randn(4,1), name = \"b\")  \n",
    "    Y = tf.add(tf.matmul(W,X),b)  \n",
    "    with tf.Session() as s:\n",
    "        result = s.run(Y)  \n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.07599585],\n",
       "       [-0.80259819],\n",
       "       [-0.71378804],\n",
       "       [-0.52456592]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linear_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## sigmod"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(z):\n",
    "    x = tf.placeholder(tf.float32, name = \"x\")  \n",
    "    sigmoid = tf.sigmoid(x)   \n",
    "    with tf.Session() as sess:  \n",
    "        result = sess.run(sigmoid,feed_dict={x:z}) \n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7310586"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sigmoid(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sigmoid(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cost\n",
    "$$ J = - \\frac{1}{m}  \\sum_{i = 1}^m  \\large ( \\small y^{(i)} \\log a^{ [2] (i)} + (1-y^{(i)})\\log (1-a^{ [2] (i)} )\\large )\\small$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cost(logits, labels):\n",
    "    z = tf.placeholder(tf.float32, name = \"z\")  \n",
    "    y = tf.placeholder(tf.float32, name = \"y\")  \n",
    "    cost = tf.nn.sigmoid_cross_entropy_with_logits(logits=z,labels=y)  \n",
    "    sess = tf.Session()  \n",
    "    cost = sess.run(cost,feed_dict={z:logits,y:labels})  \n",
    "    sess.close()      \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.0053872 , 1.0210615 , 0.42958722, 0.392987  ], dtype=float32)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cost(logits=sigmoid(np.array([.2,.3,.5,1.])),labels=np.array([0,0,1,1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 用TensorFlow建立神经网络\n",
    "## 流程\n",
    "1. 创建函数-计算图\n",
    "2. 运行函数\n",
    "\n",
    "## 问题\n",
    "<img src=\"images/6c8d61508321ac444175370124200350.png\" style=\"width:800px;height:350px;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 加载数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.python.framework import ops\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_dataset():\n",
    "    train_dataset = h5py.File('datasets/train_signs.h5', \"r\")\n",
    "    train_set_x_orig = np.array(train_dataset[\"train_set_x\"][:]) # your train set features\n",
    "    train_set_y_orig = np.array(train_dataset[\"train_set_y\"][:]) # your train set labels\n",
    "\n",
    "    test_dataset = h5py.File('datasets/test_signs.h5', \"r\")\n",
    "    test_set_x_orig = np.array(test_dataset[\"test_set_x\"][:]) # your test set features\n",
    "    test_set_y_orig = np.array(test_dataset[\"test_set_y\"][:]) # your test set labels\n",
    "\n",
    "    classes = np.array(test_dataset[\"list_classes\"][:]) # the list of classes\n",
    "    \n",
    "    train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\n",
    "    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\n",
    "    \n",
    "    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y=2\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "index=6\n",
    "plt.imshow(X_train_orig[index])\n",
    "print(\"y=\"+str(np.squeeze(Y_train_orig[:,index])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1080, 64, 64, 3), (120, 64, 64, 3))"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train_orig.shape,X_test_orig.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 整理数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 三维转一维向量\n",
    "X_train_flatten = X_train_orig.reshape(X_train_orig.shape[0], -1).T\n",
    "X_test_flatten = X_test_orig.reshape(X_test_orig.shape[0], -1).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(12288, 1080)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train_flatten.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 归一化\n",
    "X_train = X_train_flatten/255.\n",
    "X_test = X_test_flatten/255."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 1080)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y_train_orig.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y_train=np.eye(6)[Y_train_orig.ravel()].T\n",
    "Y_test=np.eye(6)[Y_test_orig.ravel()].T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1], dtype=int64), array([0., 1., 0., 0., 0., 0.]))"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index=11\n",
    "Y_train_orig[:,index],Y_train[:,index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((12288, 1080), (6, 1080), (12288, 120), (6, 120))"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape,Y_train.shape,X_test.shape,Y_test.shape,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 创建数据占位符\n",
    "训练数据=占位符"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_placeholders(n_x, n_y):\n",
    "    X = tf.placeholder(shape=[n_x, None],dtype=tf.float32)  \n",
    "    Y = tf.placeholder(shape=[n_y, None],dtype=tf.float32)  \n",
    "    return X, Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor 'Placeholder_2:0' shape=(12288, ?) dtype=float32>,\n",
       " <tf.Tensor 'Placeholder_3:0' shape=(6, ?) dtype=float32>)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X,Y=create_placeholders(X_train.shape[0],Y_train.shape[0])\n",
    "X,Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 初始化参数$W,b$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_parameters():  \n",
    "    tf.set_random_seed(1)\n",
    "    W1 = tf.get_variable(\"W1\", [25,12288], initializer = tf.contrib.layers.xavier_initializer(seed = 1))  \n",
    "    b1 = tf.get_variable(\"b1\", [25,1], initializer = tf.zeros_initializer())  \n",
    "    W2 = tf.get_variable(\"W2\", [12,25], initializer = tf.contrib.layers.xavier_initializer(seed = 1))  \n",
    "    b2 = tf.get_variable(\"b2\", [12,1], initializer = tf.zeros_initializer())  \n",
    "    W3 = tf.get_variable(\"W3\", [6,12], initializer = tf.contrib.layers.xavier_initializer(seed = 1))  \n",
    "    b3 = tf.get_variable(\"b3\", [6,1], initializer = tf.zeros_initializer())  \n",
    "    parameters = {\"W1\": W1,\n",
    "                  \"b1\": b1,\n",
    "                  \"W2\": W2,\n",
    "                  \"b2\": b2,\n",
    "                  \"W3\": W3,\n",
    "                  \"b3\": b3}    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'W1': <tf.Variable 'W1:0' shape=(25, 12288) dtype=float32_ref>,\n",
       " 'b1': <tf.Variable 'b1:0' shape=(25, 1) dtype=float32_ref>,\n",
       " 'W2': <tf.Variable 'W2:0' shape=(12, 25) dtype=float32_ref>,\n",
       " 'b2': <tf.Variable 'b2:0' shape=(12, 1) dtype=float32_ref>,\n",
       " 'W3': <tf.Variable 'W3:0' shape=(6, 12) dtype=float32_ref>,\n",
       " 'b3': <tf.Variable 'b3:0' shape=(6, 1) dtype=float32_ref>}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "with tf.Session() as sess:\n",
    "    parameters = initialize_parameters()\n",
    "parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 前向传播"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forward_propagation(X, parameters):\n",
    "    W1 = parameters['W1']\n",
    "    b1 = parameters['b1']\n",
    "    W2 = parameters['W2']\n",
    "    b2 = parameters['b2']\n",
    "    W3 = parameters['W3']\n",
    "    b3 = parameters['b3']\n",
    "    Z1 = tf.add(tf.matmul(W1,X),b1)                                             \n",
    "    A1 = tf.nn.relu(Z1)                                         \n",
    "    Z2 = tf.add(tf.matmul(W2,A1),b2)                                \n",
    "    A2 = tf.nn.relu(Z2)                                            \n",
    "    Z3 = tf.add(tf.matmul(W3,A2),b3)                                                 \n",
    "    return Z3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Add_2:0' shape=(6, ?) dtype=float32>"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "with tf.Session() as sess:\n",
    "    X, Y = create_placeholders(12288, 6)\n",
    "    parameters = initialize_parameters()\n",
    "    Z3 = forward_propagation(X, parameters)\n",
    "Z3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 成本函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost(Z3, Y):\n",
    "    logits = tf.transpose(Z3)\n",
    "    labels = tf.transpose(Y)\n",
    "    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = logits, labels = labels))  \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-53-71a7d8f7d901>:4: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See `tf.nn.softmax_cross_entropy_with_logits_v2`.\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Mean:0' shape=() dtype=float32>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "with tf.Session() as sess:\n",
    "    X, Y = create_placeholders(12288, 6)\n",
    "    parameters = initialize_parameters()\n",
    "    Z3 = forward_propagation(X, parameters)\n",
    "    cost = compute_cost(Z3, Y)\n",
    "cost"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 后向传播，梯度下降"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "optimizer = tf.train.GradientDescentOptimizer(learning_rate = learning_rate).minimize(cost)\n",
    "...\n",
    "_ , c = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 建立模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.0001,\n",
    "          num_epochs = 1500, minibatch_size = 2**5, print_cost = True):    \n",
    "    ops.reset_default_graph()\n",
    "    tf.set_random_seed(1)    \n",
    "    seed = 3                 \n",
    "    (n_x, m) = X_train.shape \n",
    "    n_y = Y_train.shape[0]   \n",
    "    costs = []               \n",
    "\n",
    "    X, Y = create_placeholders(n_x, n_y)  \n",
    "\n",
    "    parameters = initialize_parameters()  \n",
    "\n",
    "    Z3 = forward_propagation(X, parameters)  \n",
    "\n",
    "    cost = compute_cost(Z3, Y)  \n",
    "\n",
    "    optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)  \n",
    "\n",
    "    init = tf.global_variables_initializer()  \n",
    "  \n",
    "    with tf.Session() as sess:      \n",
    "        sess.run(init)            \n",
    "        for epoch in range(num_epochs):  \n",
    "  \n",
    "            epoch_cost = 0.\n",
    "            num_minibatches = int(m / minibatch_size)  \n",
    "            seed = seed + 1  \n",
    "            minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)  \n",
    "  \n",
    "            for minibatch in minibatches:  \n",
    "                (minibatch_X, minibatch_Y) = minibatch  \n",
    "                _ , minibatch_cost = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})                    \n",
    "                epoch_cost += minibatch_cost / num_minibatches  \n",
    "            if print_cost == True and epoch % 100 == 0:  \n",
    "                print (\"Cost after epoch %i: %f\" % (epoch, epoch_cost))  \n",
    "            if print_cost == True and epoch % 5 == 0:  \n",
    "                costs.append(epoch_cost)  \n",
    "\n",
    "        plt.plot(np.squeeze(costs))  \n",
    "        plt.ylabel('cost')  \n",
    "        plt.xlabel('iterations (per tens)')  \n",
    "        plt.title(\"Learning rate =\" + str(learning_rate))  \n",
    "        plt.show()  \n",
    "  \n",
    "        parameters = sess.run(parameters)  \n",
    "        print (\"Parameters have been trained!\")  \n",
    "  \n",
    "        correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))  \n",
    "  \n",
    "        accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))  \n",
    "  \n",
    "        print (\"Train Accuracy:\", accuracy.eval({X: X_train, Y: Y_train}))  \n",
    "        print (\"Test Accuracy:\", accuracy.eval({X: X_test, Y: Y_test}))  \n",
    "          \n",
    "        return parameters  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_mini_batches(X, Y, mini_batch_size = 64, seed = 0):   \n",
    "    m = X.shape[1] \n",
    "    mini_batches = []\n",
    "    np.random.seed(seed)\n",
    "    permutation = list(np.random.permutation(m))\n",
    "    shuffled_X = X[:, permutation]\n",
    "    shuffled_Y = Y[:, permutation].reshape((Y.shape[0],m))\n",
    "    \n",
    "    num_complete_minibatches = math.floor(m/mini_batch_size) \n",
    "    for k in range(0, num_complete_minibatches):\n",
    "        mini_batch_X = shuffled_X[:, k * mini_batch_size : k * mini_batch_size + mini_batch_size]\n",
    "        mini_batch_Y = shuffled_Y[:, k * mini_batch_size : k * mini_batch_size + mini_batch_size]\n",
    "        mini_batch = (mini_batch_X, mini_batch_Y)\n",
    "        mini_batches.append(mini_batch)\n",
    "\n",
    "    if m % mini_batch_size != 0:\n",
    "        mini_batch_X = shuffled_X[:, num_complete_minibatches * mini_batch_size : m]\n",
    "        mini_batch_Y = shuffled_Y[:, num_complete_minibatches * mini_batch_size : m]\n",
    "        mini_batch = (mini_batch_X, mini_batch_Y)\n",
    "        mini_batches.append(mini_batch)\n",
    "    \n",
    "    return mini_batches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after epoch 0: 1.855702\n",
      "Cost after epoch 100: 1.016458\n",
      "Cost after epoch 200: 0.733102\n",
      "Cost after epoch 300: 0.572938\n",
      "Cost after epoch 400: 0.468799\n",
      "Cost after epoch 500: 0.380979\n",
      "Cost after epoch 600: 0.313819\n",
      "Cost after epoch 700: 0.254258\n",
      "Cost after epoch 800: 0.203795\n",
      "Cost after epoch 900: 0.166410\n",
      "Cost after epoch 1000: 0.141497\n",
      "Cost after epoch 1100: 0.107579\n",
      "Cost after epoch 1200: 0.086229\n",
      "Cost after epoch 1300: 0.059415\n",
      "Cost after epoch 1400: 0.052237\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameters have been trained!\n",
      "Train Accuracy: 0.9990741\n",
      "Test Accuracy: 0.71666664\n"
     ]
    }
   ],
   "source": [
    "parameters = model(X_train, Y_train, X_test, Y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**注：**\n",
    "1. 基于训练集和测试集的表现，可以判断训练的模型存在过拟合问题，可以使用正则方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 预测"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(X, parameters):\n",
    "    \n",
    "    W1 = tf.convert_to_tensor(parameters[\"W1\"])\n",
    "    b1 = tf.convert_to_tensor(parameters[\"b1\"])\n",
    "    W2 = tf.convert_to_tensor(parameters[\"W2\"])\n",
    "    b2 = tf.convert_to_tensor(parameters[\"b2\"])\n",
    "    W3 = tf.convert_to_tensor(parameters[\"W3\"])\n",
    "    b3 = tf.convert_to_tensor(parameters[\"b3\"])\n",
    "    \n",
    "    params = {\"W1\": W1,\n",
    "              \"b1\": b1,\n",
    "              \"W2\": W2,\n",
    "              \"b2\": b2,\n",
    "              \"W3\": W3,\n",
    "              \"b3\": b3}\n",
    "    \n",
    "    x = tf.placeholder(\"float\", [12288, 1])\n",
    "    \n",
    "    z3 = forward_propagation(x, params)\n",
    "    p = tf.argmax(z3)\n",
    "    \n",
    "    sess = tf.Session()\n",
    "    prediction = sess.run(p, feed_dict = {x: X})\n",
    "        \n",
    "    return prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\env\\pythonve\\test36\\lib\\site-packages\\ipykernel_launcher.py:8: DeprecationWarning: `imread` is deprecated!\n",
      "`imread` is deprecated in SciPy 1.0.0.\n",
      "Use ``matplotlib.pyplot.imread`` instead.\n",
      "  \n",
      "d:\\env\\pythonve\\test36\\lib\\site-packages\\ipykernel_launcher.py:9: DeprecationWarning: `imresize` is deprecated!\n",
      "`imresize` is deprecated in SciPy 1.0.0, and will be removed in 1.3.0.\n",
      "Use Pillow instead: ``numpy.array(Image.fromarray(arr).resize())``.\n",
      "  if __name__ == '__main__':\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your algorithm predicts: y = 3\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import scipy\n",
    "from PIL import Image\n",
    "from scipy import ndimage\n",
    "\n",
    "my_image = \"thumbs_up.jpg\"\n",
    "\n",
    "fname = \"images/\" + my_image\n",
    "image = np.array(ndimage.imread(fname, flatten=False))\n",
    "my_image = scipy.misc.imresize(image, size=(64,64)).reshape((1, 64*64*3)).T\n",
    "my_image_prediction = predict(my_image, parameters)\n",
    "\n",
    "plt.imshow(image)\n",
    "print(\"Your algorithm predicts: y = \" + str(np.squeeze(my_image_prediction)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "487px",
    "width": "374px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
